//继承的学习

/**
 * 继承：
 * Java中使用类对现实世界的实体进行描述，类经过实例化之后的产物对象，则可以用来表示现实中的实体，但是现实世界错综复杂，
 * 事物之间可能存在一些关联
 * 比如：猫和狗
 * 用java语句创建之后，发现猫类和狗类中存在着大量的重复
 * 面向对象思想中提出了继承的概念，专门用来进行对共性的抽取，实现代码复用
 * <p>
 * 继承概念：是使得代码可以复用的重要方法，允许程序员在保持原有类特性的基础上进行扩展，增加新功能 -- 派生类(父类)
 * 继承主要解决的问题是：共性的抽取，实现代码的复用
 * 继承的语法：
 * 修饰符 class 子类 extends 父类{}
 * <p>
 * 注意：
 * 1.子类继承父类之后，会继承父类的成员方法和成员变量，但不能继承static变量，因为static修饰之后的变量，就属于是类变量了
 * 2.子类继承父类之后，必须要添加自己特有的成员，体现出与父类的不同，否则就没有必要继承了
 * 子类和父类的关系是 is - a 关系
 * 例如： Dog is an animal。
 * <p>
 * 父类成员变量和成员方法的访问
 * 1.this访问：不仅可以访问子类还可以访问父类
 * 2.用this访问子类和父类的同名变量时，子类优先访问
 * 3.super只能访问从父类继承过来的成员变量
 * 补充：super知识一个关键字，提高代码的可读性，一看到super，就直到是访问问父类的关键字
 * 4.通过派生类对象访问父类与子类同方法名的时候，如果父类和子类同方法名，参数列表不同(重载)，根据调用方法传递适合的参数选择合适的方法访问
 * <p>
 * super：主要作用：在 子类中 访问父类的成员
 * super一定是出现在子类的
 * 且只能在非静态方法中使用
 * <p>
 * 子类的构造方法：
 * 父子！先是父，再是子
 * 即：子类对象构造时，需要先调用父类（基类）构造方法，然后再执行子类的构造方法
 * <p>
 * class Dog extends Animal(){
 * public Dog(String name){
 * super(name);//调用父类构造方法
 * }//这个括号之后，子类构方法结束
 * }
 * <p>
 * 子类的构造方法中，并没有任何关于父类构造的代码，但是在构造子类对象的时候，会先执行父类的执行代码，然后执行子类的构造带吗
 * 因为：子类对象中成员是由两部分组成的，从父类继承下来的以及子类自己新添加的部分。
 * 父子肯定是先有父然后再有子，所以再构造子类对象的时候，要先调用父类的构造方法，将从父类继承下来的成员构造完整之后
 * 再调用子类自己的构造方法，把自己新添加的成员初始化完整
 * <p>
 * 1.若父类显示定义无参或者默认的构造方式，再子类构造方法的第一行就默认有隐含的super()调用，即调用父类构造方法
 * 2.如果父类构造方法是有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败
 * 3.子类构造方法中，super()调用父类构造的时候，必须是子类构造函数中的第一句
 * 4.super()只能再子类构造方法中出现一次
 * 5.super()和this()不能同时出现，因为两者都要在第一行，矛盾了无法实现
 * <p>
 * super 和 this
 * 两个关键字都可以在成员方法中访问成员变量和调用其他的成员函数，都可以作为构造方法的第一条语句
 * <p>
 * 相同点：
 * 1.都是Java的关键字
 * 2.只能在类的非静态发放中使用，来访问非静态成员方法和字段
 * 3.在构造方法中调用，必须是构造方法代码块中的第一句，且不能同时存在
 * <p>
 * 不同点：
 * 1.this是当前对象的引用，当前对象即调用实例方法的对象，super相当于是是子类对象中从父类继承下来部分成员的引用
 * 2.在非静态方法中，this用来访问本类中的对象的方法和属性，super用来访问父类中的对象和属性
 * 3.构造方法中 this()用于调用本类中的其他构造方法 super()用于调用父类中的其他构造方法
 * 4.构造方法中一定会有super()的存在，用户没有编译器也会自动增加一个，this则不会
 * <p>
 * 父类成员变量和成员方法的访问
 * 1.this访问：不仅可以访问子类还可以访问父类
 * 2.用this访问子类和父类的同名变量时，子类优先访问
 * 3.super只能访问从父类继承过来的成员变量
 * 补充：super知识一个关键字，提高代码的可读性，一看到super，就直到是访问问父类的关键字
 * 4.通过派生类对象访问父类与子类同方法名的时候，如果父类和子类同方法名，参数列表不同(重载)，根据调用方法传递适合的参数选择合适的方法访问
 * <p>
 * super：主要作用：在 子类中 访问父类的成员
 * super一定是出现在子类的
 * 且只能在非静态方法中使用
 * <p>
 * 子类的构造方法：
 * 父子！先是父，再是子
 * 即：子类对象构造时，需要先调用父类（基类）构造方法，然后再执行子类的构造方法
 * <p>
 * class Dog extends Animal(){
 * public Dog(String name){
 * super(name);//调用父类构造方法
 * }//这个括号之后，子类构方法结束
 * }
 * <p>
 * 子类的构造方法中，并没有任何关于父类构造的代码，但是在构造子类对象的时候，会先执行父类的执行代码，然后执行子类的构造带吗
 * 因为：子类对象中成员是由两部分组成的，从父类继承下来的以及子类自己新添加的部分。
 * 父子肯定是先有父然后再有子，所以再构造子类对象的时候，要先调用父类的构造方法，将从父类继承下来的成员构造完整之后
 * 再调用子类自己的构造方法，把自己新添加的成员初始化完整
 * <p>
 * 1.若父类显示定义无参或者默认的构造方式，再子类构造方法的第一行就默认有隐含的super()调用，即调用父类构造方法
 * 2.如果父类构造方法是有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败
 * 3.子类构造方法中，super()调用父类构造的时候，必须是子类构造函数中的第一句
 * 4.super()只能再子类构造方法中出现一次
 * 5.super()和this()不能同时出现，因为两者都要在第一行，矛盾了无法实现
 * <p>
 * super 和 this
 * 两个关键字都可以在成员方法中访问成员变量和调用其他的成员函数，都可以作为构造方法的第一条语句
 * <p>
 * 相同点：
 * 1.都是Java的关键字
 * 2.只能在类的非静态发放中使用，来访问非静态成员方法和字段
 * 3.在构造方法中调用，必须是构造方法代码块中的第一句，且不能同时存在
 * <p>
 * 不同点：
 * 1.this是当前对象的引用，当前对象即调用实例方法的对象，super相当于是是子类对象中从父类继承下来部分成员的引用
 * 2.在非静态方法中，this用来访问本类中的对象的方法和属性，super用来访问父类中的对象和属性
 * 3.构造方法中 this()用于调用本类中的其他构造方法 super()用于调用父类中的其他构造方法
 * 4.构造方法中一定会有super()的存在，用户没有编译器也会自动增加一个，this则不会
 * <p>
 * 父类成员变量和成员方法的访问
 * 1.this访问：不仅可以访问子类还可以访问父类
 * 2.用this访问子类和父类的同名变量时，子类优先访问
 * 3.super只能访问从父类继承过来的成员变量
 * 补充：super知识一个关键字，提高代码的可读性，一看到super，就直到是访问问父类的关键字
 * 4.通过派生类对象访问父类与子类同方法名的时候，如果父类和子类同方法名，参数列表不同(重载)，根据调用方法传递适合的参数选择合适的方法访问
 * <p>
 * super：主要作用：在 子类中 访问父类的成员
 * super一定是出现在子类的
 * 且只能在非静态方法中使用
 * <p>
 * 子类的构造方法：
 * 父子！先是父，再是子
 * 即：子类对象构造时，需要先调用父类（基类）构造方法，然后再执行子类的构造方法
 * <p>
 * class Dog extends Animal(){
 * public Dog(String name){
 * super(name);//调用父类构造方法
 * }//这个括号之后，子类构方法结束
 * }
 * <p>
 * 子类的构造方法中，并没有任何关于父类构造的代码，但是在构造子类对象的时候，会先执行父类的执行代码，然后执行子类的构造带吗
 * 因为：子类对象中成员是由两部分组成的，从父类继承下来的以及子类自己新添加的部分。
 * 父子肯定是先有父然后再有子，所以再构造子类对象的时候，要先调用父类的构造方法，将从父类继承下来的成员构造完整之后
 * 再调用子类自己的构造方法，把自己新添加的成员初始化完整
 * <p>
 * 1.若父类显示定义无参或者默认的构造方式，再子类构造方法的第一行就默认有隐含的super()调用，即调用父类构造方法
 * 2.如果父类构造方法是有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败
 * 3.子类构造方法中，super()调用父类构造的时候，必须是子类构造函数中的第一句
 * 4.super()只能再子类构造方法中出现一次
 * 5.super()和this()不能同时出现，因为两者都要在第一行，矛盾了无法实现
 * <p>
 * super 和 this
 * 两个关键字都可以在成员方法中访问成员变量和调用其他的成员函数，都可以作为构造方法的第一条语句
 * <p>
 * 相同点：
 * 1.都是Java的关键字
 * 2.只能在类的非静态发放中使用，来访问非静态成员方法和字段
 * 3.在构造方法中调用，必须是构造方法代码块中的第一句，且不能同时存在
 * <p>
 * 不同点：
 * 1.this是当前对象的引用，当前对象即调用实例方法的对象，super相当于是是子类对象中从父类继承下来部分成员的引用
 * 2.在非静态方法中，this用来访问本类中的对象的方法和属性，super用来访问父类中的对象和属性
 * 3.构造方法中 this()用于调用本类中的其他构造方法 super()用于调用父类中的其他构造方法
 * 4.构造方法中一定会有super()的存在，用户没有编译器也会自动增加一个，this则不会
 */
//public class TestOfInheritance {
//    public static void main(String[] args) {
//        Dog dog = new Dog();
//        dog.name = "wangwang";
//        dog.eat();
//        dog.sleep();
//        dog.Bark();
//    }
//}

/**
 * 父类成员变量和成员方法的访问
 * 1.this访问：不仅可以访问子类还可以访问父类
 * 2.用this访问子类和父类的同名变量时，子类优先访问
 * 3.super只能访问从父类继承过来的成员变量
 * 补充：super知识一个关键字，提高代码的可读性，一看到super，就直到是访问问父类的关键字
 * 4.通过派生类对象访问父类与子类同方法名的时候，如果父类和子类同方法名，参数列表不同(重载)，根据调用方法传递适合的参数选择合适的方法访问
 *
 * super：主要作用：在 子类中 访问父类的成员
 * super一定是出现在子类的
 * 且只能在非静态方法中使用
 */

//class Base {
//    int a = 1;
//    int b = 2;
//    int d = 5;
//}
//
//class Derived extends Base {
//    int a = 3;
//    int c = 4;
//    public void method(){
//        System.out.println("子类中的a = " + this.a);
//        System.out.println("父类中的a = " + super.a);
//        System.out.println("b = " + b );
//        System.out.println("c = " + c);
//        System.out.println("d = " + d);
//    }
//}
//public class TestOfInheritance {
//    public static void main(String[] args) {
//        Derived test = new Derived();
//        test.method();
//    }
//}


/**
 * 子类的构造方法：
 * 父子！先是父，再是子
 * 即：子类对象构造时，需要先调用父类（基类）构造方法，然后再执行子类的构造方法
 *
 * class Dog extends Animal(){
 *     public Dog(String name){
 *         super(name);//调用父类构造方法
 *     }//这个括号之后，子类构方法结束
 * }
 *
 * 子类的构造方法中，并没有任何关于父类构造的代码，但是在构造子类对象的时候，会先执行父类的执行代码，然后执行子类的构造带吗
 * 因为：子类对象中成员是由两部分组成的，从父类继承下来的以及子类自己新添加的部分。
 * 父子肯定是先有父然后再有子，所以再构造子类对象的时候，要先调用父类的构造方法，将从父类继承下来的成员构造完整之后
 * 再调用子类自己的构造方法，把自己新添加的成员初始化完整
 *
 * 1.若父类显示定义无参或者默认的构造方式，再子类构造方法的第一行就默认有隐含的super()调用，即调用父类构造方法
 * 2.如果父类构造方法是有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败
 * 3.子类构造方法中，super()调用父类构造的时候，必须是子类构造函数中的第一句
 * 4.super()只能再子类构造方法中出现一次
 * 5.super()和this()不能同时出现，因为两者都要在第一行，矛盾了无法实现
 */


/**
 * super 和 this
 * 两个关键字都可以在成员方法中访问成员变量和调用其他的成员函数，都可以作为构造方法的第一条语句
 *
 * 相同点：
 * 1.都是Java的关键字
 * 2.只能在类的非静态发放中使用，来访问非静态成员方法和字段
 * 3.在构造方法中调用，必须是构造方法代码块中的第一句，且不能同时存在
 *
 *不同点：
 * 1.this是当前对象的引用，当前对象即调用实例方法的对象，super相当于是是子类对象中从父类继承下来部分成员的引用
 * 2.在非静态方法中，this用来访问本类中的对象的方法和属性，super用来访问父类中的对象和属性
 * 3.构造方法中 this()用于调用本类中的其他构造方法 super()用于调用父类中的其他构造方法
 * 4.构造方法中一定会有super()的存在，用户没有编译器也会自动增加一个，this则不会
 */


/**
 * 继承关系：Java中不支持多继承，即class C 既继承A 又继承B
 * 但可以class B 和 class C 同时继承 class A
 */

//*


        // * final关键字
        // * final：最终的
        // * 1.修饰变量或字符，表示常量不能修改
//        final int a = 20;
//        a = 50;//err
        //2.修饰类：表示该类不能再被继承
        //3.修饰方法：表示该方法不能被重写
        //4.修饰数组
        // final int[] arr = {1,2,3,4};
        // a.  arr = new int[10];
        // b.  arr[0] = 99;
        //a有问题会报错


//继承和组合
//和继承类似，组合也是一种表达类之间的关系，也能实现代码复用的效果，但并没有关键字，只是一种思想
//继承是 is - a 关系
//组合是 has - a 关系 或者 a part of 关系

